home *** CD-ROM | disk | FTP | other *** search
/ PCMania 36 / PCMania CD36_1.iso / pcmania / c36 / ascpov2.c < prev   
C/C++ Source or Header  |  1980-03-14  |  18KB  |  607 lines
  1. #include <stdio.h>
  2. #include <math.h>
  3. #include <dos.h>
  4. #include <stdarg.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <conio.h>
  8.  
  9.  
  10. unsigned int searchtext(unsigned char *, unsigned char *,
  11.                         unsigned int, FILE *);
  12. unsigned int sigword(unsigned char *, unsigned int);
  13. unsigned int tomanombre(unsigned char *, unsigned char *, unsigned int);
  14. unsigned int tomanom_s(unsigned char *, unsigned char *, unsigned int);
  15. void retocapov(void);
  16. void cargar(FILE *);
  17. void normalp(unsigned int);
  18.  
  19.  
  20. #define maxlon 12192
  21. #define razonC 35.2044      /* constante para conversion de la camara */
  22. unsigned char bufferR[maxlon]; /* buffer para datos de F. a leer */
  23. double vertices[19000][3];   /* reservar espacio para un max. de 19000 vertices */
  24. double normal[38000][3];     /* las normales de un max. de 38000 caras */
  25. unsigned int caras[38000][3];/* ind. los vertices de cada cara (para un
  26.                                calculo rapido de las normales de los vert.) */
  27. FILE *fichasc;              /* handle para fichero .asc a leer */
  28. FILE *fichpov;              /* handle para fichero .pov a escribir */
  29. FILE *fichinc;              /* handle para fichero .inc a escribir */
  30. unsigned int posr;          /* pos. relativa dentro del buffer */
  31. unsigned char string[50];   /* cadenas de trabajo */
  32. unsigned char string1[50];
  33. unsigned char nombref[30];
  34. unsigned char mam[30];
  35. unsigned char mam1[30];
  36. unsigned char textur[30];
  37. unsigned char libtex[60][30];   /* libreria de texturas (max. 60) */
  38. int primtex;                /* indica prim. zona libre de libtext */
  39. double xi,yi,zi,xf,yf,zf;    /* valores intermedios para calculo de normales */
  40. unsigned nvertices,nfaces;  /* num. de vertices y caras de objeto en curso */
  41.  
  42. main()
  43. {
  44. long a,b,c;
  45. char d;
  46. double pella;
  47. int nobj;
  48. double v0,v1,v2;             /* valores de comparacion de triangulos degen. */
  49.  
  50. nobj=0;
  51. posr=0;
  52. primtex=0;
  53. /* scr_setmode(3); */
  54. puts("                    Ascpov 0.9 por Jose Manuel Muñoz Perez\n");
  55. /* exec("\\command.com", "/cdir /w *.asc"); */
  56. system("dir /w *.asc");     /* sustituye a la linea anterior */
  57. printf("indica el fichero 3dstudio (ASC) a tratar ");
  58. scanf("%s",mam);
  59. strcpy(string,mam);
  60. strcat(string,".asc");
  61. if ((fichasc=fopen(string,"r"))==0)
  62.  {
  63.  printf("\n Error: El fichero no puede abrirse!\n\n");
  64.  exit(1);
  65.  }
  66.  
  67. strcpy(string,mam);
  68. strcpy(nombref,string);     /* preservar nombre del F. */
  69. strcat(string,".inc");
  70. strcpy(string1,string);     /* preservar nombre.inc */
  71. if ((fichinc=fopen(string,"w"))==0)
  72.  {
  73.  printf("\n Error: El fichero no puede crearse!\n\n");
  74.  exit(1);
  75.  }
  76.  
  77. strcpy(string,mam);
  78. strcat(string,".pov");
  79. if ((fichpov=fopen(string,"w"))==0)
  80.  {
  81.  printf("\n Error: El fichero no puede crearse!\n\n");
  82.  exit(1);
  83.  }
  84.  
  85. cargar(fichasc);            /* cargar 70 lineas del f. */
  86. posr=0;
  87.  
  88. /* poner includes basicos */
  89. fputs("#include \"colors.inc\"\n",fichpov);
  90. fputs("#include \"textures.inc\"\n",fichpov);
  91.  
  92. /* buscar objeto */
  93. buscaobj:
  94. nobj++;
  95. posr=searchtext(bufferR,"Named object:",posr,fichasc);
  96.  
  97. if (posr==65535)
  98.  {
  99.  retocapov();               /* poner texturas de objetos y nombres de
  100.                                estos en la union final */
  101.  fclose(fichasc);
  102.  fclose(fichpov);
  103.  fclose(fichinc);
  104.  exit(0);
  105.  }
  106. posr=sigword(bufferR,posr); /* nos posicionamos sobre el nombre del objeto */
  107. posr++;                     /* nos saltamos las comillas del nombre */
  108. posr=tomanombre(bufferR,mam,posr); 
  109. /* metemos el nombre del objeto en 'mam' */
  110. a=strlen(mam);
  111. mam[a-1]=0;                 /* quitamos las comillas del nombre poniendo
  112.     un 0 (fin de cadena, ¿recuerdan?) */
  113. posr=sigword(bufferR,posr); /* nos posicionamos sobre la siguiente palabra
  114.     (el tipo de objeto; Camera, Direct light, Tri-mesh (objeto)) */
  115. posr=tomanom_s(bufferR,mam1,posr);
  116.  
  117. printf("currando sobre objeto ");
  118. printf("%s\n",mam);
  119. /* ya tenemos el tipo de objeto en mam1[] */
  120. if (!strcmp(mam1,"Camera"))
  121.  {
  122. /* primero nos posicionamos sobre la "lente" de la camara */
  123.  posr=sigword(bufferR,posr);
  124.  posr++;
  125.  pella=atof(bufferR+posr);
  126.  pella/=razonC;             /* calculado el "Zoom" de la camara */
  127.  fputs("camera {\n location <",fichpov);
  128.  posr-=10;
  129.  posr=searchtext(bufferR,"Position:",posr,fichasc);
  130.  posr=sigword(bufferR,posr);
  131.  posr+=2;                   /* con esto estamos posicionados sobre la X */
  132.  posr=tomanom_s(bufferR,mam1,posr);
  133.  fputs(mam1,fichpov);
  134.  fputs(", ",fichpov);
  135.  posr+=3;
  136.  posr=tomanom_s(bufferR,mam1,posr);
  137.  fputs(mam1,fichpov);
  138.  fputs(", ",fichpov);
  139.  posr+=3;
  140.  posr=tomanom_s(bufferR,mam1,posr);
  141.  fputs(mam1,fichpov);
  142.  fputs(">\n",fichpov);
  143.  fputs(" direction <0.0, ",fichpov);
  144.  fprintf(fichpov,"%f",pella);
  145.  fputs(", 0.0>\n up  <0.0, 0.0, 1.0>\n",fichpov);
  146.  fputs(" sky <0, 0, 1>\n",fichpov);
  147.  fputs(" right <1.33,0.0, 0.0>\n look_at <",fichpov);
  148.  posr=searchtext(bufferR,"X:",posr,fichasc);
  149. /* esta X correponde a Target (punto al que apunta la camara) */
  150.  posr=tomanom_s(bufferR,mam1,posr);
  151.  fputs(mam1,fichpov);
  152.  fputs(", ",fichpov);
  153.  posr+=3;
  154.  posr=tomanom_s(bufferR,mam1,posr);
  155.  fputs(mam1,fichpov);
  156.  fputs(", ",fichpov);
  157.  posr+=3;
  158.  posr=tomanom_s(bufferR,mam1,posr);
  159.  fputs(mam1,fichpov);
  160.  fputs(">\n}\n\n",fichpov);
  161.  
  162.  }
  163.  
  164.  
  165. else if (!strcmp(mam1,"Direct"))
  166.  {                          /* por "Direct light" */
  167.  fputs("light_source {<",fichpov);
  168.  posr=searchtext(bufferR,"X:",posr,fichasc);
  169. /* la primera "X:" corresponde a la "Position" de la luz (consultar
  170.    el fichero .asc) */
  171.  posr=tomanom_s(bufferR,mam1,posr);
  172.  fputs(mam1,fichpov);
  173.  fputs(", ",fichpov);
  174.  posr+=3;
  175.  posr=tomanom_s(bufferR,mam1,posr);
  176.  fputs(mam1,fichpov);
  177.  fputs(", ",fichpov);
  178.  posr+=3;
  179.  posr=tomanom_s(bufferR,mam1,posr);
  180.  fputs(mam1,fichpov);
  181.  fputs(">\n color rgb <",fichpov);
  182.  
  183.  posr=searchtext(bufferR,"Red=",posr,fichasc);
  184. /* esto esta dentro de la orden "Light color" del fichero .asc */
  185.  posr=tomanom_s(bufferR,mam1,posr);
  186.  fputs(mam1,fichpov);       /* componente rojo de la luz */
  187.  fputs(", ",fichpov);
  188.  posr=searchtext(bufferR,"Green=",posr,fichasc);
  189.  posr=tomanom_s(bufferR,mam1,posr);
  190.  fputs(mam1,fichpov);       /* componente verde */
  191.  fputs(", ",fichpov);
  192.  posr=searchtext(bufferR,"Blue=",posr,fichasc);
  193.  posr=tomanom_s(bufferR,mam1,posr);
  194.  fputs(mam1,fichpov);       /* componente azul */
  195.  fputs(">\n}\n\n",fichpov);
  196.  
  197.  }
  198.  
  199.  
  200. else if (!strcmp(mam1,"Tri-mesh,"))
  201.  {
  202.  fputs("#declare ",fichinc);
  203.  fputs(mam,fichinc);
  204.  fputs("=union{\n",fichinc);
  205.  
  206.  posr=searchtext(bufferR,"Vertices:",posr,fichasc);
  207.  posr++;                    /* saltar espacio en blanco */
  208.  nvertices=atoi(bufferR+posr);
  209.  posr=searchtext(bufferR,"Faces:",posr,fichasc);
  210.  posr++;                    /* saltar espacio en blanco */
  211.  nfaces=atoi(bufferR+posr);
  212. /* ahora tomar los vertices. Primero nos situamos en el primero -el 0 */
  213.  posr=searchtext(bufferR,"Vertex 0:",posr,fichasc);
  214.  
  215.  for (a=0;a<nvertices;a++)
  216.   {
  217.   posr=searchtext(bufferR,"X:",posr,fichasc);
  218.   pella=atof(bufferR+posr);
  219.   vertices[a][0]=pella;
  220.   posr=searchtext(bufferR,"Y:",posr,fichasc);
  221.   pella=atof(bufferR+posr);
  222.   vertices[a][1]=pella;
  223.   posr=searchtext(bufferR,"Z:",posr,fichasc);
  224.   pella=atof(bufferR+posr); /* esto es por si el atof() de PCC da problems */
  225.   vertices[a][2]=pella;
  226.   } 
  227.   
  228. /* ahora tomaremos los datos de la lista de caras */
  229.  posr=searchtext(bufferR,"Face list:",posr,fichasc);
  230.  for (a=0;a<nfaces;a++)
  231.   {
  232.   posr=searchtext(bufferR,"Face ",posr,fichasc);
  233.   posr=searchtext(bufferR," A:",posr,fichasc); 
  234.   caras[a][0]=atoi(bufferR+posr);   /* tomar 1er vertice del triangulo */
  235.   posr=searchtext(bufferR," B:",posr,fichasc); 
  236.   caras[a][1]=atoi(bufferR+posr);   /* tomar 2ndo vertice del triangulo */
  237.   posr=searchtext(bufferR," C:",posr,fichasc); 
  238.   caras[a][2]=atoi(bufferR+posr);   /* tomar 3er vertice del triangulo */
  239.  
  240.   if (a==0)                 /* tomar nombre de textura (si lo hay) */
  241.    {
  242. /* primero buscar primer caracter de las palabras "Material", "Smoothing"
  243.    o "Face", (Material es que el objeto tiene una textura, Smoothing que
  244.    carece de ella, pero el objeto tiene un contorno suavizado) */
  245.    while(bufferR[posr]!='M' && bufferR[posr]!='S' &&
  246.          bufferR[posr]!='F' && bufferR[posr]!=255)
  247.     posr++;
  248.    if (bufferR[posr]==255)
  249.     {                       /* ultima linea de carga anterior */
  250.     cargar(fichasc);        /* leer otra tanda de lineas */
  251.     posr=0;
  252.     }
  253.    else if (bufferR[posr]=='F')
  254.     {
  255.     strcpy(textur,"defecto");
  256.     continue;
  257.     } 
  258.    else if (bufferR[posr]=='M')
  259.     {
  260.     posr+=10;               /* posicionarnos sobre el nombre de la text. */
  261.     c=0;
  262.     while(bufferR[posr]!='"')
  263.      {
  264. /* las dos lin. sigs. estan porque el nombre de textura puede tener
  265.    espacios dentro (por eso no empleamos tomanombre() ¡¡@#⌠⌡AG!! */
  266.      if (bufferR[posr]==32)
  267.       mam1[c]='_';
  268.      else
  269.       mam1[c]=bufferR[posr]; 
  270.      c++;
  271.      posr++;
  272.      }
  273.     mam1[c]=0;
  274.     strcpy(textur,mam1);    /* ya tenemos en textur[] el nombre de text. */
  275.     }
  276.    else
  277.     strcpy(textur,"defecto");
  278. /* finalmente miramos si la textura esta o no en la lista de nombres de
  279.    texturas */
  280.    for (c=0;c<primtex;c++)
  281.     {
  282.     if (!strcmp(textur,libtex[c]))
  283.      goto salirtex;         /* si, ya se que los puristas pediran mi sangre
  284.                                por esta linea... */
  285.     }
  286.    strcpy(libtex[primtex],textur);
  287.    primtex++;               /* apuntar a prox. nombre de text. libre */
  288.    }
  289. salirtex:
  290.   continue;
  291.   }
  292.  
  293.  
  294. /* ahora crear tabla normal[], donde guardaremos las normales calculadas
  295.    de cada poligono */
  296.  for (a=0;a<nfaces;a++)
  297.   {
  298.   xi=vertices[caras[a][1]][0] - vertices[caras[a][0]][0];
  299.   yi=vertices[caras[a][1]][1] - vertices[caras[a][0]][1];
  300.   zi=vertices[caras[a][1]][2] - vertices[caras[a][0]][2];
  301.   
  302.   xf=vertices[caras[a][2]][0] - vertices[caras[a][0]][0];
  303.   yf=vertices[caras[a][2]][1] - vertices[caras[a][0]][1];
  304.   zf=vertices[caras[a][2]][2] - vertices[caras[a][0]][2];
  305.  
  306.   normal[a][0]= (yi*zf) - (zi*yf);  /* X */
  307.   normal[a][1]= (zi*xf) - (xi*zf);  /* Y */
  308.   normal[a][2]= (xi*yf) - (yi*xf);  /* Z */
  309.   }
  310.   
  311. /* ahora escribir cada smooth_triangle. Para cada vertice hay que hacer un
  312.    bucle de busqueda en caras[] para ver en cuantas de las caras del objeto 
  313.    interviene dicho vertice. (La normal de cada vertice se calcula con el
  314.    promedio de las normales de las caras que emplean el susodicho vertice). */
  315.  for (a=0;a<nfaces;a++)
  316.   {
  317. /* antes que nada, comprobar si el triangulo es degenerado. v0 es la suma de
  318.    los val. X,Y,Z del vertice 0, v1 la suma del vertice 2 e idem. para v2 */
  319.   v0=vertices[caras[a][0]][0]+vertices[caras[a][0]][1]+
  320.      vertices[caras[a][0]][2];
  321.   v1=vertices[caras[a][1]][0]+vertices[caras[a][1]][1]+
  322.      vertices[caras[a][1]][2];
  323.   v2=vertices[caras[a][2]][0]+vertices[caras[a][2]][1]+
  324.      vertices[caras[a][2]][2];
  325.   if (v0==v1 || v0==v2 || v1==v2)
  326.    continue;                /* desechamos este triangulo */
  327.   else
  328.    {
  329.    fputs(" smooth_triangle{\n  <",fichinc);
  330.    fprintf(fichinc,"%f",vertices[caras[a][0]][0]);
  331.    fputs(", ",fichinc);
  332.    fprintf(fichinc,"%f",vertices[caras[a][0]][1]);
  333.    fputs(", ",fichinc);
  334.    fprintf(fichinc,"%f",vertices[caras[a][0]][2]);
  335.    fputs(">  <",fichinc);
  336.    normalp(caras[a][0]);    /* calcular la normal promediada del vertice 0 */
  337. /* los valores devueltos estan en xi, yi y zi */
  338.    fprintf(fichinc,"%f",xi);
  339.    fputs(", ",fichinc);
  340.    fprintf(fichinc,"%f",yi);
  341.    fputs(", ",fichinc);
  342.    fprintf(fichinc,"%f",zi);
  343.    fputs(">\n  <",fichinc);
  344. /* ahora el vertice 1 */
  345.    fprintf(fichinc,"%f",vertices[caras[a][1]][0]);
  346.    fputs(", ",fichinc);
  347.    fprintf(fichinc,"%f",vertices[caras[a][1]][1]);
  348.    fputs(", ",fichinc);
  349.    fprintf(fichinc,"%f",vertices[caras[a][1]][2]);
  350.    fputs(">  <",fichinc);
  351.    normalp(caras[a][1]);    /* calcular la normal promediada del vertice 1 */
  352.    fprintf(fichinc,"%f",xi);
  353.    fputs(", ",fichinc);
  354.    fprintf(fichinc,"%f",yi);
  355.    fputs(", ",fichinc);
  356.    fprintf(fichinc,"%f",zi);
  357.    fputs(">\n  <",fichinc);
  358. /* ahora el vertice 2 */
  359.    fprintf(fichinc,"%f",vertices[caras[a][2]][0]);
  360.    fputs(", ",fichinc);
  361.    fprintf(fichinc,"%f",vertices[caras[a][2]][1]);
  362.    fputs(", ",fichinc);
  363.    fprintf(fichinc,"%f",vertices[caras[a][2]][2]);
  364.    fputs(">  <",fichinc);
  365.    normalp(caras[a][2]);    /* calcular la normal promediada del vertice 2 */
  366.    fprintf(fichinc,"%f",xi);
  367.    fputs(", ",fichinc);
  368.    fprintf(fichinc,"%f",yi);
  369.    fputs(", ",fichinc);
  370.    fprintf(fichinc,"%f",zi);
  371.    fputs(">}\n",fichinc);
  372.    }
  373.   }
  374.  
  375.  
  376.  fputs("texture {",fichinc);
  377.  fputs(textur,fichinc);
  378.  fputs("}\n}\n",fichinc);
  379.  }
  380. goto buscaobj;
  381. }
  382.  
  383.  
  384. /* Esta funcion busca una cadena de texto dentro de un array de caracteres.
  385.    Devuelve 65535 si no lo ha hallado o un valor entero indicando su pos.
  386.    en dicho array. La funcion acepta como parametros un puntero a la cadena
  387.    donde va a efectuarse la busqueda, otro puntero a la cadena que se va a
  388.    buscar y un indice al punto de principio para la busqueda (puede ser
  389.    preciso que la investigacion no comienze desde el principio).
  390.    Cuando una ocurrencia sobrepase las ultimas lineas de la carga anterior
  391.    se leera otra tanda de lineas (por ello tambien adjuntamos el puntero
  392.    *FILE al fichero que deseamos leer). logicamente en ese caso el indice
  393.    a devolver continuara la busqueda desde 0 */
  394. unsigned int searchtext(unsigned char *buffer, unsigned char *text,
  395.                         unsigned int desp, FILE *fich)
  396. {
  397. long a,b,c;
  398. unsigned char loncad;
  399. int d;
  400.  
  401.  a=0;                   
  402.  loncad=strlen(text);
  403. sigcar:
  404.  while(buffer[desp]!=text[a] && buffer[desp]!=255 && buffer[desp]!=0)
  405.   desp++;
  406.  
  407.  if (buffer[desp]==255)
  408.   {
  409.   cargar(fich);             /* leer mas lineas */    
  410.   desp=0;
  411.   goto sigcar;
  412.   }   
  413.  
  414.  if (buffer[desp]==0)
  415.   return(65535);            /* marca de que no se ha hallado correspondencia */ 
  416.  
  417. /* si llega aqui, es que se ha leido el car. */
  418.  d=desp;
  419.  for (b=0,c=desp;b<loncad-1;a++,b++,c++)
  420.   {
  421.   if (buffer[c]!=text[a])
  422.    {
  423.    a=0;
  424.    desp++; 
  425.    goto sigcar;
  426.    }
  427.   }
  428.  
  429.  a=d+loncad;
  430.  return (a);
  431. /* a=d+loncad es porque el indice devuelto corresponde a la primera pos.
  432.    del array, despues de la ocurrencia hallada */ 
  433. }
  434.  
  435.  
  436. /* llamamos a sigword() cuando deseamos hallar el indice dentro del array
  437.    a la sig. palabra que sigue a la ultima procesada (indicada por desp) */
  438. unsigned int sigword(unsigned char *buffer, unsigned int desp)
  439. {
  440.  
  441. /* primero nos saltamos los car. de la palabra actual */
  442. while(buffer[desp]!=32 && buffer[desp]!=13 &&
  443.       buffer[desp]!=10 && buffer[desp]!=255)
  444.  desp++;
  445. if (bufferR[desp]==255)
  446.  {                          /* ultima linea de carga anterior */
  447.  cargar(fichasc);           /* leer otra tanda de lineas */
  448.  desp=0;
  449.  }
  450.  
  451. /* y ahora los espacios hasta la siguiente palabra */
  452. while((buffer[desp]==32 || buffer[desp]==13 || buffer[desp]==10) &&
  453.        buffer[desp]!=255)
  454.  desp++;
  455. if (bufferR[desp]==255)
  456.  {                          
  457.  cargar(fichasc);           
  458.  desp=0;
  459.  }
  460.  
  461. return desp;
  462. }
  463.  
  464.  
  465. /* toma el nombre alterando algunos caracteres que no permite el POV */
  466. unsigned int tomanombre(unsigned char *buffer, 
  467.                         unsigned char *text, unsigned int desp)
  468. {
  469. unsigned char a;
  470.  
  471. a=0;
  472. while(buffer[desp]!=32 && buffer[desp]!=13 && buffer[desp]!=10)
  473.  {
  474.  if ((buffer[desp]>=48 && buffer[desp]<=57) || buffer[desp]=='"' ||
  475.      (buffer[desp]>=65 && buffer[desp]<=90) ||
  476.      (buffer[desp]>=97 && buffer[desp]<=122))
  477.   text[a]=buffer[desp];     /* es uno de los car. permitidos por POV */
  478.  else
  479.   text[a]='_';
  480.  a++;
  481.  desp++;
  482.  }
  483. text[a]=0;                  /* marca para fin de cadena */
  484. return desp;
  485. }
  486.  
  487.  
  488. /* toma el nombre sin alteraciones */
  489. unsigned int tomanom_s(unsigned char *buffer,
  490.                        unsigned char *text, unsigned int desp)
  491. {
  492. unsigned char a;
  493.  
  494. a=0;
  495. while(buffer[desp]!=32 && buffer[desp]!=13 && buffer[desp]!=10)
  496.  {
  497.  text[a]=buffer[desp];
  498.  a++;
  499.  desp++;
  500.  }
  501. text[a]=0;                  /* marca para fin de cadena */
  502. return desp;
  503. }
  504.  
  505.  
  506. /* Pone las plantillas para las texturas y los nombres de los objetos en la
  507.    "union" del fichero.pov */
  508. void retocapov(void)
  509. {
  510. unsigned int a,b;
  511. int d;
  512.  
  513. puts("ajustando fichero .pov");
  514. fclose(fichinc);        
  515. for(b=0;b<primtex;b++)
  516.  {
  517.  fputs("#declare ",fichpov);
  518.  fputs(libtex[b],fichpov);
  519.  fputs("= texture{\n pigment {White}\n",fichpov);
  520.  fputs(" finish {\n  specular 1\n  roughness 0.001\n }\n}\n\n",fichpov);
  521.  }
  522.  
  523. fputs("#include \"",fichpov);
  524. fputs(string1,fichpov);
  525. fputs("\"\n\n",fichpov);
  526.  
  527. /* abrimos nuevamente el fichero, para reinicializar el indicador de
  528.    posicion de archivo. Naturalmente, en vez de esto podriamos haber usado
  529.    fseek() */
  530. if ((fichinc=fopen(string1,"r"))==0)
  531.  {
  532.  printf("\n Error: El fichero no puede abrirse!\n\n");
  533.  exit(1);
  534.  }
  535.  
  536. cargar(fichinc);            /* cargar 70 lineas del f. */
  537. posr=0;
  538.  
  539. /* ahora incluimos en el f. pov la lista de objetos definidos en el F. 
  540.    .inc. Por supuesto esto puede ser retoc. por el usuario */
  541. fputs("// lista de objetos de la escena\n\n  ",fichpov);
  542. for(;;)
  543.  {
  544.  posr=searchtext(bufferR,"declare",posr,fichinc);
  545.  if (posr==65535)
  546.   return;
  547.  posr=sigword(bufferR,posr);
  548.  posr=tomanom_s(bufferR,string,posr); 
  549.  a=0;
  550.  
  551.  while(string[a]!='=')
  552.   a++;
  553.  string[a]=0;
  554.  fputs(string,fichpov);
  555.  fputs("\n  ",fichpov);
  556.  }
  557. }
  558.  
  559.  
  560. /* ahora leer 80 lineas como maximo a partir de bufferR+0 */
  561. void cargar(FILE *fich)
  562. {
  563. unsigned int a,b,c;
  564. int d;
  565.  
  566. for (a=0,b=80;b!=0;b--)
  567.  {
  568.  d=fgets(bufferR+a,512,fich);
  569.  if (d!=0)
  570.   {
  571.   while (bufferR[a]!=0)
  572.    a++;
  573.   }
  574.  else 
  575.   return;
  576.  }
  577. if (d!=0)
  578.  bufferR[a]=255;            /* marca de ultima de las 70 lineas */
  579. }   
  580.  
  581.  
  582. /* calcular la normal promediada del vertice */
  583. void normalp(unsigned int vert)
  584. {
  585. unsigned int a,b;
  586.  
  587. xi=0;
  588. yi=0;
  589. zi=0;
  590. b=0;        /* num. de caras de las que forma parte el vertice */
  591. for (a=0;a<nfaces;a++)
  592.  {
  593.  if (vert==caras[a][0] || vert==caras[a][1] || vert==caras[a][2])
  594.   {
  595.   b++;      /* el vertice forma parte de esta cara */
  596.   xi+=normal[a][0];
  597.   yi+=normal[a][1];
  598.   zi+=normal[a][2];
  599.   }
  600.  }
  601.  xi/=b;     /* hallar el promedio */
  602.  yi/=b;
  603.  zi/=b;
  604. }
  605.  
  606.  
  607.